/* 2023-12-14 by Liz */
import request from '@/utils/request'
export function isBoolean(value) {
    return typeof value === 'boolean';
}
export function isObject(value) {
    return typeof value === 'object' && value !== null && !Array.isArray(value);
}
export function isArray(value) {
    return Array.isArray(value);
}
export function isString(value) {
    return typeof value === 'string';
}
export function isNumber(value) {
    return typeof value === 'number';
}
export function isFunction(value) {
    return typeof value === 'function';
}
export function isUndefined(value) {
    return typeof value === 'undefined';
}
export function isNull(value) {
    return value === null;
}
/* 判断字段是否为空：'', [], {}，undefined，null */
export function isEmpty(value) {
    if (isArray(value) || isString(value)) {
        return value.length === 0;
    } else if (isObject(value)) {
        return Object.keys(value).length === 0;
    } else if (value === null || value === undefined) {
        return true;
    }
    return false;
}
export function isNotEmpty(value) {
    return !isEmpty(value);
}
export function isNotNull(value) {
    return value!== null && value!== undefined;
}
export function isNotUndefined(value) {
    return value!== undefined;
}
export function isHtml(str) {  
    var div = document.createElement("div");  
    div.innerHTML = str;  
    return div.childNodes.length > 0;  
}
/* 解析模板 */
export function parseTemplate(template, data) {
    if (!template) return '';
    const result = template.replace(/\${(.+?)}/g, (match, key) => {
        return data[key] || match;
    });
    return result || template;
}
// 解析展示字段中包含'.'的情况，直接返回值
export function parseSpecField(field, row) {
    if (!field) return '';
    const fieldArr = field.split('.');
    if (fieldArr.length === 1) return row[field];
    // 使用 reduce() 函数逐步转换为嵌套的对象属性
    const reset = fieldArr.reduce(function(obj, part) {
        if (!obj || isEmpty(obj[part])) return
        return obj[part];
    }, row);
    return reset;
}
// { a: { b: 1 }, c: { d: { e: 2 } }, f: 3 } => {'a.b': 1, 'c.d.e': 2, 'f': 3}
export function flattenObject(obj, parentKey = '', result = {}) {
    Object.keys(obj).forEach(key => {
        const value = obj[key];
        const newKey = parentKey ? `${parentKey}.${key}` : key;

        if (value && typeof value === 'object' && !Array.isArray(value)) {
            // 如果值是一个对象并且不是数组，递归处理
            flattenObject(value, newKey, result);
        } else {
            // 否则，将键值对添加到结果对象中
            result[newKey] = value;
        }
    });
    return result;
}
// {'a.b': 1, 'c.d.e': 2, 'f': 3} => { a: { b: 1 }, c: { d: { e: 2 } }, f: 3 }
export function flattenToNested(obj) {
    let result = {};
    
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            let parts = key.split('.');
            let lastPart = parts.pop();
            let current = result;
            
            for (let part of parts) {
                if (!current[part]) {
                    current[part] = {};
                }
                current = current[part];
            }
            
            current[lastPart] = obj[key];
        }
    }
    
    return result;
}
/* 解析url参数 */
export function parseString(str, key) {
    let param = {};
    str.replace(/([^?&]+)=([^?&]+)/g, function (s, v, k) {
        param[v] = decodeURIComponent(k);
    });
    return key ? param[key] : param;
}
/* 删除首尾空格 "  Hello World  " ==> "Hello World" */
export function trim(str) {
    return str.replace(/(^\s+)|(\s+$)/g, "");
}

export function string2Boolean(str) {
    let newStr;
    if (typeof str === 'string' && (str === 'true' || str === 'false')) {
        // 直接使用 === 进行比较，并转换为布尔值
        newStr = str === 'true';
    }
    return newStr;
}

export function dateFormatter(str, type) {
    if (!str && !type) return str;
   /* 获取年月日时分秒 */
    const d = new Date(str);
    const year = d.getFullYear();
    const month = (d.getMonth() + 1).toString().padStart(2, '0');
    const day = d.getDate().toString().padStart(2, '0');
    const hours = d.getHours().toString().padStart(2, '0');
    const minutes = d.getMinutes().toString().padStart(2, '0');
    const seconds = d.getSeconds().toString().padStart(2, '0');
    let formattedDate = `${year}.${month}.${day}`;
   /* 根据type返回指定结果 */
    if (type === 'YYYY-MM-DD') {
      formattedDate = `${year}-${month}-${day}`;
    } else if (type === 'HH:MM:SS') {
      formattedDate = `${hours}:${minutes}:${seconds}`;
    } else if (type === 'YYYY-MM-DD HH:mm:ss' || type === 'YYYY-MM-DD  HH:MM:SS'){
      formattedDate = `${year}-${month}-${day }  ${ hours}:${minutes}:${seconds}`;
    }
    return formattedDate;
}

export function formatDate(dateString, format) {
    // 使用日期对象和模板字符串来格式化日期
    const date = new Date(dateString);
    const year = date.getFullYear(); // 获取年份
    const month = (date.getMonth() + 1).toString().padStart(2, '0'); // 获取月份，转换为两位数
    const day = date.getDate().toString().padStart(2, '0'); // 获取日期，转换为两位数
    const hours = date.getHours().toString().padStart(2, '0'); // 获取小时，转换为两位数
    const minutes = date.getMinutes().toString().padStart(2, '0'); // 获取分钟，转换为两位数
    const seconds = date.getSeconds().toString().padStart(2, '0'); // 获取秒数，转换为两位数
    // 返回格式化后的日期字符串
    if (format) {
        return format
            .replace('YYYY', year)
            .replace('MM', month)
            .replace('DD', day)
            .replace('HH', hours)
            .replace('mm', minutes)
            .replace('ss', seconds);
    } else {
        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
    }
}
export const http = {
    get: function (url, params, config) {
        return request({
            url,
            method: 'get',
            params,
            ...config,
        })
    },
    post: function (url, data, config) {
        return request({
            url,
            method: 'post',
            data,
            ...config,
        })
    },
    formData: function (url, data, config) {
        const formData = new FormData();
        for (const key in data) {
            formData.append(key, data[key]);
        }
        return request({
            url,
            method: 'post',
            data: formData,
            headers: {
                'Content-Type': 'multipart/form-data;boundary = ' + new Date().getTime(),
            },
            ...config,
        })
    }
}
export function deepClone(obj, hash = new WeakMap()) {
    if (Object(obj) !== obj) return obj; // Primitive value
    if (hash.has(obj)) return hash.get(obj); // Circular reference
  
    let result;
    if (obj instanceof Set) {
      result = new Set();
      hash.set(obj, result);
      obj.forEach(value => result.add(deepClone(value, hash)));
    } else if (obj instanceof Map) {
      result = new Map();
      hash.set(obj, result);
      obj.forEach((value, key) => result.set(key, deepClone(value, hash)));
    } else if (obj instanceof Date) {
      return new Date(obj);
    } else if (obj instanceof RegExp) {
      return new RegExp(obj);
    } else if (Array.isArray(obj)) {
      result = [];
      hash.set(obj, result);
      obj.forEach((value, index) => result[index] = deepClone(value, hash));
    } else if (typeof obj === 'object' && obj !== null) {
      result = {};
      hash.set(obj, result);
      for (const key in obj) {
        if (obj.hasOwnProperty(key)) {
          result[key] = deepClone(obj[key], hash);
        }
      }
    } else {
      throw new Error("Unable to clone object! Its type isn't supported.");
    }
  
    return result;
  }
  // 合并两个数组，后面对象覆盖前面数组，如果存在则更新，不存在则添加
export function mergeArray(existingFields = [], sortedFields = [], key = 'prop') {
    // 创建一个映射，用于快速查找现有字段的位置
    const indexMap = new Map(existingFields.map((field, index) => [field[key], index]));
    
    // 创建一个新的字段列表，按照sortedFields的顺序更新existingFields中的字段
    const updatedFields = existingFields.slice(); // 复制现有字段

    sortedFields.forEach(sortedField => {
        if (indexMap.has(sortedField[key])) {
            // 如果已存在，则替换为新的字段值（假设字段是对象且需要更新）
            // 如果只是简单的字符串或者不需要更新内容，可以跳过这一步
            const index = indexMap.get(sortedField[key]);
            updatedFields[index] = sortedField;
        } else {
            // 如果不存在，则追加到末尾
            updatedFields.unshift(sortedField);
        }
    });

    // 返回更新后的字段列表
    return updatedFields;
}
  // css 字符串转对象
  export function parseCssString(cssString) {
    // 移除空格，并按照分号分割成数组
    const cssArray = cssString.replace(/\s/g, '').split(';');
    
    // 过滤掉可能存在的空项，并将每个样式属性映射到对象上
    return cssArray.filter(item => item).reduce((acc, item) => {
      // 按照冒号分割键和值
      const [key, value] = item.split(':');
      acc[key] = value; // 将其添加到累加器对象中
      return acc;
    }, {});
}